Map в Java это интерфейс-словарь: он хранит пары «ключ-значение», ключи в нем уникальны, а значения повторяться могут. По умолчанию берут HashMap, перебирают мапу через entrySet(), сортируют либо выгрузив пары в список, либо взяв TreeMap, а в список превращают через конструктор ArrayList. Ниже семь самых частых вопросов по Map, на каждый есть готовый код.

Кратко

  • Перебор: for (Map.Entry<K, V> entry : map.entrySet()). Методы getKey() и getValue() достают из пары ключ и значение.
  • В List мапа превращается через конструктор ArrayList: keySet() даст ключи, values() значения, entrySet() пары целиком.
  • Разовая сортировка: выгрузить entrySet() в список и отсортировать компаратором. Постоянная: взять TreeMap, он держит ключи упорядоченными сам.
  • TreeMap сортирует по ключам, а не хранит порядок добавления. Порядок добавления держит LinkedHashMap.
  • HashMap разрешает null и в ключе, и в значении, Hashtable не разрешает нигде, а TreeMap не берет null-ключ при обычной сортировке.
  • Hashtable синхронизирован, но это устаревший класс: для многопоточности документация Oracle советует ConcurrentHashMap.
Привет! Если ты уже освоил основы работы с HashMap (а если нет, советую начать с нашей статьи "HashMap в Java"), то наверняка у тебя появились дополнительные вопросы. Как перебирать элементы мапы? Как ее отсортировать? В чем разница между разными реализациями Map? Сегодня мы дадим ответы на самые распространенные вопросы о Map, но для начала давай вспомним, что это такое. Ключ в замке приоткрытой двери, на ключе висит связка других ключей

Что такое Map в Java

Map это структура данных, которая содержит набор пар “ключ-значение”. По своей структуре данных напоминает словарь, поэтому ее часто так и называют. В то же время, Map является интерфейсом, и в стандартном JDK содержит основные реализации: HashMap, LinkedHashMap, Hashtable, TreeMap. Самая используемая реализация это HashMap, поэтому и будем ее использовать в наших примерах. Вот так выглядит стандартное создание и заполнение мапы:

Map<Integer, String> map = new HashMap<>();
map.put(1, "string 1");
map.put(2, "string 2");
map.put(3, "string 3");
А так выглядит получение значений по ключу:

String string1 = map.get(1);
String string2 = map.get(2);
String string3 = map.get(3);
Если все из вышесказанного понятно, приступим к нашим ответам на популярные вопросы!

0. Как перебрать все значения Map

Перебор значений это самая частая операция, которую вы выполняете с мапами. Все пары (ключ-значение) хранятся во внутреннем интерфейсе Map.Entry, а чтобы получить их, нужно вызвать метод entrySet(). Он возвращает множество (Set) пар, которые можно перебрать в цикле:

for(Map.Entry<Integer, String> entry: map.entrySet()) {
   // get key
   Integer key = entry.getKey();
   // get value
   String value = entry.getValue();
}
Или то же самое через итератор:

Iterator<Map.Entry<Integer, String>> itr = map.entrySet().iterator();
while(itr.hasNext()) {
   Map.Entry<Integer, String> entry =  itr.next();
   // get key
   Integer key = entry.getKey();
   // get value
   String value = entry.getValue();
}

1. Как конвертировать Map в List

У интерфейса Map существует 3 метода, которые возвращают перечень элементов:
  • keySet() возвращает множество (Set) ключей;
  • values() возвращает коллекцию (Collection) значений;
  • entrySet() возвращает множество (Set) наборов “ключ-значение”.
Если заглянуть в конструкторы класса ArrayList, можно заметить, что существует конструктор с аргументом типа Collection. Так как Set является наследником Collection, результаты всех вышеупомянутых методов можно передать в конструктор класса ArrayList. Таким образом, мы создадим новые списки и заполним их значениями из Map: Тут стоит запомнить одну деталь: сами по себе keySet(), values() и entrySet() копий не делают, они возвращают представления мапы. Пока вы работаете с ними напрямую, изменения мапы видны через них, а изменения через них меняют мапу. Копия появляется ровно в тот момент, когда вы передаете представление в конструктор ArrayList:

// key list
List<Integer> keyList = new ArrayList<>(map.keySet());
// value list
List<String> valueList = new ArrayList<>(map.values());
// key-value list
List<Map.Entry<Integer, String>> entryList = new ArrayList<>(map.entrySet());

2. Как отсортировать ключи мапы

Сортировка мап тоже довольно частая операция в программировании. Сделать это можно несколькими способами:
  1. Поместить Map.Entry в список и отсортировать его, используя Comparator.

    В компараторе будем сравнивать исключительно ключи пар:

    
    List<Map.Entry<Integer, String>> list = new ArrayList(map.entrySet());
    Collections.sort(list, new Comparator<Map.Entry<Integer, String>>() {
       @Override
       public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
           return Integer.compare(o1.getKey(), o2.getKey());
       }
    });
    
    Ключи тут сравниваются через Integer.compare, а не вычитанием одного из другого. Разница видна не сразу, но она есть: у int вычитание умеет переполняться, и на больших по модулю ключах разных знаков компаратор вернет число с неправильным знаком, из-за чего сортировка молча собьется.

    Если разобрался с лямбдами, эту запись можно существенно сократить:

    
    Collections.sort(list, Comparator.comparingInt(Map.Entry::getKey));
    
  2. Использовать SortedMap, а точнее, ее реализацию TreeMap, которая в конструкторе принимает Comparator. Данный компаратор будет применяться к ключам мапы. Обратите внимание: требование Comparable работает наоборот. Реализовывать этот интерфейс ключи обязаны как раз тогда, когда компаратора нет и TreeMap сортирует по натуральному порядку. Если компаратор передан, порядок задает он, и ключам Comparable уже не нужен, так и написано в документации TreeMap:

    
    SortedMap<Integer, String> sortedMap = new TreeMap<>(new Comparator<Integer>() {
       @Override
       public int compare(Integer o1, Integer o2) {
           return Integer.compare(o1, o2);
       }
    });
    

    И, конечно, все можно переписать, используя лямбды:

    
    SortedMap<Integer, String> sortedMap = new TreeMap<>(Comparator.comparingInt(o -> o));
    

    В отличие от первого способа, используя SortedMap, мы всегда будем хранить данные в отсортированном виде.

3. Как отсортировать значения мапы

Здесь стоит использовать подход, аналогичный первому для ключей: выгрузить пары в список и отсортировать их компаратором, который сравнивает уже не ключи, а значения:

List <Map.Entry<Integer, String>> valuesList = new ArrayList(map.entrySet());
Collections.sort(valuesList, new Comparator<Map.Entry<Integer, String>>() {
   @Override
   public int compare(Map.Entry<Integer, String> o1, Map.Entry<Integer, String> o2) {
       return o1.getValue().compareTo(o2.getValue());
   }
});
И лямбда для этого выглядит так:

Collections.sort(valuesList, Comparator.comparing(Map.Entry::getValue));

4. В чем разница между HashMap, LinkedHashMap, TreeMap и Hashtable

Как упоминалось ранее, существуют 4 основные реализации интерфейса Map. У каждой из них есть свои особенности:
  1. Порядок элементов. HashMap и Hashtable не гарантируют, что элементы будут храниться в порядке добавления. Кроме того, они не гарантируют, что порядок элементов не будет меняться со временем. В свою очередь, TreeMap держит элементы отсортированными по ключам: по натуральному порядку ключей или по переданному компаратору. Порядок добавления он как раз не сохраняет, за это отвечает LinkedHashMap.

  2. Допустимые значения. HashMap позволяет иметь ключ и значение null, Hashtable не позволяет ни того, ни другого. У TreeMap ограничение касается только ключей: при сортировке по натуральному порядку null-ключ дает NullPointerException, и пройдет он лишь тогда, когда переданный компаратор явно умеет сравнивать null. А вот значения null в TreeMap допустимы всегда. LinkedHashMap в этом смысле ничем не отличается от HashMap: null можно и в ключе, и в значении.

  3. Синхронизация. Из этой четверки синхронизирован только Hashtable, остальные нет. Если к мапе не будут обращаться разные потоки, рекомендуется использовать HashMap вместо Hashtable. А если потоки все-таки будут, Hashtable сегодня тоже не лучший выбор: это класс из самой первой версии Java, и его собственная документация советует брать вместо него ConcurrentHashMap.

И общее сравнение реализаций:
HashMap LinkedHashMap Hashtable TreeMap
Упорядоченность элементов нет да, по порядку добавления нет да, по ключам
null в качестве ключа да да нет нет
null в качестве значения да да нет да
Потокобезопасность нет нет да нет
Алгоритмическая сложность поиска элементов O(1) в среднем O(1) в среднем O(1) в среднем O(log n)
Структура данных под капотом хэш-таблица хэш-таблица плюс двусвязный список хэш-таблица красно-черное дерево

5. Как создать двунаправленную мапу

Иногда появляется необходимость использовать структуру данных, в которой и ключи, и значения будут уникальными, то есть мапа будет содержать пары “ключ-ключ”. Такая структура данных позволяет создать "инвертированный просмотр/поиск" по мапе. То есть, мы можем найти ключ по его значению. Эту структуру данных называют двунаправленной мапой, которая, к сожалению, не поддерживается JDK. Но, к счастью, ее реализацию можно найти в библиотеках Apache Commons Collections или Guava. Там она называется BidiMap и BiMap соответственно. Эти реализации вводят ограничения на уникальность ключей и значений. Таким образом получаются отношения one-to-one.

6. Как создать пустую Map

Создать пустую мапу можно тремя способами:
  1. Обычная инициализация объекта:

    
    Map<Integer, String> emptyMap = new HashMap<>();
    
  2. Создание неизменяемой (immutable) пустой мапы:

    
    Map<Integer, String> emptyMap =  Collections.emptyMap();
    
  3. То же самое через фабричный метод Map.of(), который появился в Java 9:

    
    Map<Integer, String> emptyMap = Map.of();
    
При попытке добавления данных в такую мапу мы получим: UnsupportedOperationException исключение.

7. Что появилось в Map после Java 8

Примеры выше написаны так, как писали во времена Java 7: цикл по entrySet(), Collections.sort, Collections.emptyMap(). Все это работает и сегодня, но с Java 8 у Map появились методы, которые ту же работу делают короче. Их стоит знать хотя бы для того, чтобы понимать чужой код.

forEach вместо цикла

Если внутри цикла ты просто что-то делаешь с каждой парой, целый for можно не писать:

map.forEach((key, value) -> System.out.println(key + " = " + value));

getOrDefault вместо проверки на null

Метод возвращает значение по ключу, а если такого ключа в мапе нет, то указанное значение по умолчанию:

String value = map.getOrDefault(42, "ключ не найден");
Одна тонкость: подмена срабатывает, только когда ключа нет вовсе. Если ключ есть, но сопоставлен null, вернется именно null.

computeIfAbsent и merge вместо трех строк

Два самых полезных метода на практике. computeIfAbsent достает значение по ключу, а если его нет, создает и сразу кладет в мапу. Классический случай это мапа со списками внутри:

Map<String, List<String>> groups = new HashMap<>();
groups.computeIfAbsent("f", k -> new ArrayList<>()).add("Ford");
groups.computeIfAbsent("f", k -> new ArrayList<>()).add("Ferrari");
// groups = {f=[Ford, Ferrari]}
А merge кладет значение, если ключа не было, и объединяет старое значение с новым, если ключ уже есть. Счетчики пишутся в одну строку:

Map<String, Integer> counters = new HashMap<>();
for (String word : words) {
    counters.merge(word, 1, Integer::sum);
}

Map.of вместо ручного заполнения

С Java 9 маленькую неизменяемую мапу можно собрать одним вызовом, а с Java 10 еще и сделать неизменяемую копию существующей:

Map<Integer, String> constants = Map.of(1, "string 1", 2, "string 2");
Map<Integer, String> copy = Map.copyOf(map);
У таких мап есть три правила, о которых лучше узнать заранее, а не из упавшего приложения. Они не принимают null ни в ключе, ни в значении и бросают на этом NullPointerException. Они отвергают дубликаты ключей при создании, это уже IllegalArgumentException. И порядок перебора у них не определен, полагаться на него нельзя. Все три пункта прямо перечислены в разделе Unmodifiable Maps документации Map.

Сортировка через Stream API

Разделы 2 и 3 можно переписать без промежуточного списка. Map.Entry с Java 8 сам умеет отдавать компараторы по ключу и по значению:

List<Map.Entry<Integer, String>> sorted = map.entrySet().stream()
        .sorted(Map.Entry.comparingByValue())
        .collect(Collectors.toList());
А если нужен не список, а мапа, в которой порядок сохранится, собирать надо именно в LinkedHashMap: обычный Collectors.toMap отдаст HashMap, и вся сортировка пропадет.

Map<Integer, String> sortedMap = map.entrySet().stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                (a, b) -> a, LinkedHashMap::new));
В этой статье мы рассмотрели самые частые вопросы, которые могли возникнуть у тебя при использовании интерфейса Map.

Вопросы и ответы

Чем Map отличается от Collection?

Map не наследует Collection, это два разных корня иерархии. Collection это набор одиночных элементов, а Map хранит пары. Поэтому у Map нет ни метода add, ни метода iterator, зато есть put и get, а до содержимого добираются через три представления: keySet, values и entrySet.

Что будет, если положить в мапу два одинаковых ключа?

Второй вызов put не добавит новую пару, а перезапишет значение у существующего ключа и вернет старое значение. В документации это сформулировано жестко: мапа не может содержать повторяющихся ключей. Равенство ключей HashMap определяет через hashCode и equals, поэтому у классов, которые используются как ключи, оба метода должны быть переопределены согласованно.

Можно ли удалять элементы из мапы прямо в цикле по entrySet?

Через саму мапу нельзя: итератор заметит стороннее изменение и на следующем шаге бросит ConcurrentModificationException. Удалять нужно либо методом remove у итератора entrySet, либо методом removeIf у нужного представления, например map.entrySet().removeIf(...) или map.values().removeIf(...).

Как достать значение и не проверять результат на null?

Для этого есть метод getOrDefault: он возвращает значение по ключу, а если такого ключа нет, то переданное значение по умолчанию. Метод появился в Java 8 и заменяет связку из containsKey и get. Важная тонкость: подмена срабатывает, только когда ключа в мапе нет вовсе. Если ключ есть, но сопоставлен null, вернется именно null, а не значение по умолчанию.

Какую реализацию Map выбрать?

Если порядок не важен и нужна скорость, берите HashMap. Если при переборе нужен порядок добавления, LinkedHashMap. Если нужны ключи в отсортированном виде, TreeMap. Если мапа общая для нескольких потоков, ConcurrentHashMap. Hashtable сегодня встречается только в старом коде.

Как сделать мапу неизменяемой?

Готовую мапу заворачивают в Collections.unmodifiableMap, но это именно представление: правки в исходной мапе будут видны и через обертку. Если нужна независимая неизменяемая мапа, с Java 9 есть Map.of для сборки из пар, а с Java 10 еще и Map.copyOf для копии существующей. Любая попытка записи в такую мапу дает UnsupportedOperationException.